home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / vser11 / vser.txt < prev   
Text File  |  1995-02-26  |  25KB  |  566 lines
  1.  
  2.  
  3.  
  4.     ╔════════════════════════════════════════════════════════════════════╗
  5.     ║                                                                    ║
  6.     ║                                                                    ║
  7.     ║                     Visible::Serialization(tm)                     ║
  8.     ║                     --------------------------                     ║
  9.     ║                developers' serialization utilities                 ║
  10.     ║                                                                    ║
  11.     ║                                                                    ║
  12.     ║     append serial numbers (or other identifiers) to .exe files     ║
  13.     ║                                                                    ║
  14.     ║                                                                    ║
  15.     ║                                                                    ║
  16.     ║                     a product of RCCO Research                     ║
  17.     ║                                                                    ║
  18.     ║                                                                    ║
  19.     ╚════════════════════════════════════════════════════════════════════╝
  20.  
  21.  
  22.  
  23. Capabilities
  24. -------------
  25. Visible::Serialization(tm) is a utilities set primarily intended for
  26. developers so that they may append serial numbers (or other identifiers) to
  27. .exe files, create and/or increment such serial numbers, and search for and
  28. verify/display serializations.  Users other than developers may use
  29. Visible::Serialization to initialize purchased software applications with
  30. ownership, security-related, or other identifying marks.
  31.  
  32. A unique serial number going out with each copy of an application affords
  33. the developer with a possible opportunity to identify, if need be, the
  34. registered client of a particular copy.  The end-user is normally unaware
  35. of the existence of such a mark, its location, its method of placement or
  36. the method of reading/verifying.  Its absence or modification may provide
  37. evidence of tampering.
  38.  
  39. Visible::Serialization may be used with most traditional MS-DOS or Windows
  40. executables, including those created with CA-Clipper, Borland Turbo Pascal,
  41. QuickBASIC, PowerBasic, Visual Basic(tm) for Windows or DOS, FoxPro, Clarion,
  42. C/C++, etc.
  43.  
  44. The chief advantages, aside from the utilities themselves, are both low cost
  45. and method of acquiring.  The copy included herewith is a fully-functional
  46. evaluation copy available easily and universally through the user-supported
  47. software marketplace.
  48.  
  49.  
  50.  
  51.  
  52. The Visible::Serialization package
  53. -----------------------------------
  54. This set of utilities consists of the following primary files:
  55.  
  56.          CREATESN.EXE  (create or increment a serialno.dat file)
  57.          APPENDSN.EXE  (append a serial string in serialno.dat to an .exe)
  58.          SEARCHSN.EXE  (search/verify an .exe for a serial string)
  59.  
  60. Also included are:
  61.  
  62.          SN2A.BAT      (sample batch file for production of successive
  63.                            serializations on distribution diskettes)
  64.          SERIALNO.DAT  (sample numerical serial number data file for
  65.                            reading by APPENDSN.EXE; not needed or
  66.                            necessarily distributed with applications)
  67.          SAMPLE.EXE    (sample c file .exe on which to practice append
  68.                            and search sessions)
  69.  
  70.  
  71.  
  72.  
  73. Using Visible::Serialization
  74. -----------------------------
  75. CreateSN.exe
  76. -------------
  77. You may use CreateSN.exe to create an ASCII text file called serialno.dat
  78. containing a beginning numerical sequence or an alphanumeric string to be
  79. used by the AppendSN.exe utility.  You may create and use both a numerical
  80. serial number (which can be incremented by subsequent runs of CreateSN.exe)
  81. or an alphanumeric string (including letters, digits, punctuation marks and
  82. spaces).
  83.  
  84. If there is in the working directory for the project at hand a file called
  85. serialno.dat, CreateSN.exe will attempt to increment a numerical serial
  86. number up to nine (9) digits by one number.  For example, if the serialno.dat
  87. file contains the number 10001, running CreateSN from the command line will
  88. change serialno.dat to 10002.  If serialno.dat contains characters other
  89. than digits, or contains a digital sequence greater than 9 in length, or
  90. is a numerical serial number file created or modified by a text editor
  91. (rather than CreateSN.exe itself), a message will report that the sequence
  92. cannot be incremented.
  93.  
  94. If a serialno.dat file is not found in the current directory, CreateSN.exe
  95. will prompt you for a beginning serial number.  You may enter either a
  96. numerical sequence or any alphanumeric string up to 34 characters in length.
  97. Only if you intend to have CreateSN increment the sequence later must you
  98. limit the length and content to 9 digits or less, with no letters, spaces or
  99. punctuation marks.
  100.  
  101. After appropriate entry of a new sequence or an increment of an existing
  102. sequence, CreateSN.exe will indicate successful completion and display the
  103. new serialno.dat file typed to the screen for verification.  The serialno.dat
  104. is now ready for use by AppendSN.exe.
  105.  
  106.  
  107.  
  108. AppendSN.exe
  109. -------------
  110. To use AppendSN.exe, you type at the DOS prompt:
  111.  
  112.                         appendsn <filename.exe>
  113.  
  114. and press <enter>, where <filename.exe> is the actual copy of the .exe file
  115. you wish to serialize.  We provide a practice file in this package,
  116. sample.exe, for purposes of trying the append and search/read operations.
  117. (You may wish to retain an unchanged copy of the original sample.exe for
  118. evaluating various serialization sequences and the resulting appends.)
  119.  
  120. If there exists in the current directory an appropriate serialno.dat file,
  121. AppendSN.exe will read the sequence therein.  If the sequence consists of
  122. 34 or less characters in length, AppendSN.exe will append that sequence to
  123. the end of the .exe file named as the required command line parameter.  (If
  124. serialno.dat contains a sequence in excess of 34 characters, an appropriate
  125. message will display, accompanied by an exit to the system prompt.)
  126.  
  127. For example, if the serialno.dat file contains the sequence of digits 10002,
  128. and you execute
  129.  
  130.                         appendsn sample.exe <enter>
  131.  
  132. then 10002 will be appended to the end of sample.exe.  Should the serialno.dat
  133. file contain the sequence:  10002 John C. Smith, then that exact sequence
  134. will be appended to sample.exe.  A serialno.dat file containing "Property of
  135. XYZ Corp." will cause that string to be appended to sample.exe.
  136.  
  137. You may use as a filename for appending purposes a complete pathname (up to
  138. 80 characters); i.e.,
  139.  
  140.                         appendsn a:\subdir\sample.exe <enter>
  141.  
  142. DOS wildcard characters (i.e., *.exe) are not permitted, however; single
  143. filenames must be used with each append.  The serialno.dat file must be
  144. located in the directory that is current, not the target directory.
  145.  
  146. After successful completion of the append, AppendSN.exe will note that with
  147. an appropriate message.
  148.  
  149.  
  150.  
  151. SearchSN.exe
  152. -------------
  153. The third utility in the Visible::Serialization set is SearchSN.exe.  You
  154. may use SearchSN.exe to search/verify an .exe for a serial string.  If you
  155. take the original, unserialized copy of sample.exe and type
  156.  
  157.                         searchsn sample.exe <enter>
  158.  
  159. you should receive a message stating "Serial number not found."
  160.  
  161. If the .exe file has been initialized with a serial number sequence by
  162. using AppendSN.exe (as above), then the results will be a partial dump
  163. of that area of the .exe showing our program name followed by the appended
  164. serialization sequence.  There may also be a few garbage characters or
  165. other text displayed as well, but these should not interfere with the reading
  166. or verification of the true serialization sequence.  There are, however,
  167. infrequent instances in which an executable's serialization sequence may be
  168. improperly displayed; see the appropriate paragraphs on SearchSN.exe in the
  169. Notes & Precautions section, below.
  170.  
  171. You may use as a filename for searching purposes a complete pa